home *** CD-ROM | disk | FTP | other *** search
/ American Osteopathic Ass…tion Yearbook 2005 & 2006 / American Osteopathic Association Yearbook 2005 & 2006.iso / mac / app / sre_compile.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2004-07-22  |  12.6 KB  |  506 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.3)
  3.  
  4. '''Internal support module for sre'''
  5. import _sre
  6. import sys
  7. from sre_constants import *
  8. if not _sre.MAGIC == MAGIC:
  9.     raise AssertionError, 'SRE module mismatch'
  10. if _sre.CODESIZE == 2:
  11.     MAXCODE = 65535
  12. else:
  13.     MAXCODE = 0xFFFFFFFFL
  14.  
  15. def _compile(code, pattern, flags):
  16.     emit = code.append
  17.     for op, av in pattern:
  18.         if op in (LITERAL, NOT_LITERAL):
  19.             if flags & SRE_FLAG_IGNORECASE:
  20.                 emit(OPCODES[OP_IGNORE[op]])
  21.                 emit(_sre.getlower(av, flags))
  22.             else:
  23.                 emit(OPCODES[op])
  24.                 emit(av)
  25.         flags & SRE_FLAG_IGNORECASE
  26.         if op is IN:
  27.             if flags & SRE_FLAG_IGNORECASE:
  28.                 emit(OPCODES[OP_IGNORE[op]])
  29.                 
  30.                 def fixup(literal, flags = flags):
  31.                     return _sre.getlower(literal, flags)
  32.  
  33.             else:
  34.                 emit(OPCODES[op])
  35.                 
  36.                 fixup = lambda x: x
  37.             skip = len(code)
  38.             emit(0)
  39.             _compile_charset(av, flags, code, fixup)
  40.             code[skip] = len(code) - skip
  41.             continue
  42.         if op is ANY:
  43.             if flags & SRE_FLAG_DOTALL:
  44.                 emit(OPCODES[ANY_ALL])
  45.             else:
  46.                 emit(OPCODES[ANY])
  47.         flags & SRE_FLAG_DOTALL
  48.         if op in (REPEAT, MIN_REPEAT, MAX_REPEAT):
  49.             if flags & SRE_FLAG_TEMPLATE:
  50.                 raise error, 'internal: unsupported template operator'
  51.                 emit(OPCODES[REPEAT])
  52.                 skip = len(code)
  53.                 emit(0)
  54.                 emit(av[0])
  55.                 emit(av[1])
  56.                 _compile(code, av[2], flags)
  57.                 emit(OPCODES[SUCCESS])
  58.                 code[skip] = len(code) - skip
  59.             elif _simple(av) and op != REPEAT:
  60.                 if op == MAX_REPEAT:
  61.                     emit(OPCODES[REPEAT_ONE])
  62.                 else:
  63.                     emit(OPCODES[MIN_REPEAT_ONE])
  64.                 skip = len(code)
  65.                 emit(0)
  66.                 emit(av[0])
  67.                 emit(av[1])
  68.                 _compile(code, av[2], flags)
  69.                 emit(OPCODES[SUCCESS])
  70.                 code[skip] = len(code) - skip
  71.             else:
  72.                 emit(OPCODES[REPEAT])
  73.                 skip = len(code)
  74.                 emit(0)
  75.                 emit(av[0])
  76.                 emit(av[1])
  77.                 _compile(code, av[2], flags)
  78.                 code[skip] = len(code) - skip
  79.                 if op == MAX_REPEAT:
  80.                     emit(OPCODES[MAX_UNTIL])
  81.                 else:
  82.                     emit(OPCODES[MIN_UNTIL])
  83.         op == MAX_REPEAT
  84.         if op is SUBPATTERN:
  85.             if av[0]:
  86.                 emit(OPCODES[MARK])
  87.                 emit((av[0] - 1) * 2)
  88.             
  89.             _compile(code, av[1], flags)
  90.             if av[0]:
  91.                 emit(OPCODES[MARK])
  92.                 emit((av[0] - 1) * 2 + 1)
  93.             
  94.         av[0]
  95.         if op in (SUCCESS, FAILURE):
  96.             emit(OPCODES[op])
  97.             continue
  98.         if op in (ASSERT, ASSERT_NOT):
  99.             emit(OPCODES[op])
  100.             skip = len(code)
  101.             emit(0)
  102.             if av[0] >= 0:
  103.                 emit(0)
  104.             else:
  105.                 (lo, hi) = av[1].getwidth()
  106.                 if lo != hi:
  107.                     raise error, 'look-behind requires fixed-width pattern'
  108.                 
  109.                 emit(lo)
  110.             _compile(code, av[1], flags)
  111.             emit(OPCODES[SUCCESS])
  112.             code[skip] = len(code) - skip
  113.             continue
  114.         if op is CALL:
  115.             emit(OPCODES[op])
  116.             skip = len(code)
  117.             emit(0)
  118.             _compile(code, av, flags)
  119.             emit(OPCODES[SUCCESS])
  120.             code[skip] = len(code) - skip
  121.             continue
  122.         if op is AT:
  123.             emit(OPCODES[op])
  124.             if flags & SRE_FLAG_MULTILINE:
  125.                 av = AT_MULTILINE.get(av, av)
  126.             
  127.             if flags & SRE_FLAG_LOCALE:
  128.                 av = AT_LOCALE.get(av, av)
  129.             elif flags & SRE_FLAG_UNICODE:
  130.                 av = AT_UNICODE.get(av, av)
  131.             
  132.             emit(ATCODES[av])
  133.             continue
  134.         if op is BRANCH:
  135.             emit(OPCODES[op])
  136.             tail = []
  137.             for av in av[1]:
  138.                 skip = len(code)
  139.                 emit(0)
  140.                 _compile(code, av, flags)
  141.                 emit(OPCODES[JUMP])
  142.                 tail.append(len(code))
  143.                 emit(0)
  144.                 code[skip] = len(code) - skip
  145.             
  146.             emit(0)
  147.             for tail in tail:
  148.                 code[tail] = len(code) - tail
  149.             
  150.         if op is CATEGORY:
  151.             emit(OPCODES[op])
  152.             if flags & SRE_FLAG_LOCALE:
  153.                 av = CH_LOCALE[av]
  154.             elif flags & SRE_FLAG_UNICODE:
  155.                 av = CH_UNICODE[av]
  156.             
  157.             emit(CHCODES[av])
  158.             continue
  159.         if op is GROUPREF:
  160.             if flags & SRE_FLAG_IGNORECASE:
  161.                 emit(OPCODES[OP_IGNORE[op]])
  162.             else:
  163.                 emit(OPCODES[op])
  164.             emit(av - 1)
  165.             continue
  166.         raise ValueError, ('unsupported operand type', op)
  167.     
  168.  
  169.  
  170. def _compile_charset(charset, flags, code, fixup = None):
  171.     emit = code.append
  172.     if fixup is None:
  173.         
  174.         fixup = lambda x: x
  175.     
  176.     for op, av in _optimize_charset(charset, fixup):
  177.         emit(OPCODES[op])
  178.         if op is NEGATE:
  179.             continue
  180.         if op is LITERAL:
  181.             emit(fixup(av))
  182.             continue
  183.         if op is RANGE:
  184.             emit(fixup(av[0]))
  185.             emit(fixup(av[1]))
  186.             continue
  187.         if op is CHARSET:
  188.             code.extend(av)
  189.             continue
  190.         if op is BIGCHARSET:
  191.             code.extend(av)
  192.             continue
  193.         if op is CATEGORY:
  194.             if flags & SRE_FLAG_LOCALE:
  195.                 emit(CHCODES[CH_LOCALE[av]])
  196.             elif flags & SRE_FLAG_UNICODE:
  197.                 emit(CHCODES[CH_UNICODE[av]])
  198.             else:
  199.                 emit(CHCODES[av])
  200.         flags & SRE_FLAG_LOCALE
  201.         raise error, 'internal: unsupported set operator'
  202.     
  203.     emit(OPCODES[FAILURE])
  204.  
  205.  
  206. def _optimize_charset(charset, fixup):
  207.     out = []
  208.     charmap = [
  209.         0] * 256
  210.     
  211.     try:
  212.         for op, av in charset:
  213.             if op is NEGATE:
  214.                 out.append((op, av))
  215.                 continue
  216.             if op is LITERAL:
  217.                 charmap[fixup(av)] = 1
  218.                 continue
  219.             if op is RANGE:
  220.                 for i in range(fixup(av[0]), fixup(av[1]) + 1):
  221.                     charmap[i] = 1
  222.                 
  223.             if op is CATEGORY:
  224.                 return charset
  225.                 continue
  226.     except IndexError:
  227.         return _optimize_unicode(charset, fixup)
  228.  
  229.     i = p = n = 0
  230.     runs = []
  231.     for c in charmap:
  232.         if c:
  233.             if n == 0:
  234.                 p = i
  235.             
  236.             n = n + 1
  237.         elif n:
  238.             runs.append((p, n))
  239.             n = 0
  240.         
  241.         i = i + 1
  242.     
  243.     if n:
  244.         runs.append((p, n))
  245.     
  246.     if len(runs) <= 2:
  247.         for p, n in runs:
  248.             if n == 1:
  249.                 out.append((LITERAL, p))
  250.                 continue
  251.             out.append((RANGE, (p, p + n - 1)))
  252.         
  253.         if len(out) < len(charset):
  254.             return out
  255.         
  256.     else:
  257.         data = _mk_bitmap(charmap)
  258.         out.append((CHARSET, data))
  259.         return out
  260.     return charset
  261.  
  262.  
  263. def _mk_bitmap(bits):
  264.     data = []
  265.     if _sre.CODESIZE == 2:
  266.         start = (1, 0)
  267.     else:
  268.         start = (0x1L, 0x0L)
  269.     (m, v) = start
  270.     for c in bits:
  271.         if c:
  272.             v = v + m
  273.         
  274.         m = m << 1
  275.         if m > MAXCODE:
  276.             data.append(v)
  277.             (m, v) = start
  278.             continue
  279.     
  280.     return data
  281.  
  282.  
  283. def _optimize_unicode(charset, fixup):
  284.     
  285.     try:
  286.         import array
  287.     except ImportError:
  288.         return charset
  289.  
  290.     charmap = [
  291.         0] * 65536
  292.     negate = 0
  293.     
  294.     try:
  295.         for op, av in charset:
  296.             if op is NEGATE:
  297.                 negate = 1
  298.                 continue
  299.             if op is LITERAL:
  300.                 charmap[fixup(av)] = 1
  301.                 continue
  302.             if op is RANGE:
  303.                 for i in range(fixup(av[0]), fixup(av[1]) + 1):
  304.                     charmap[i] = 1
  305.                 
  306.             if op is CATEGORY:
  307.                 return charset
  308.                 continue
  309.     except IndexError:
  310.         return charset
  311.  
  312.     if negate:
  313.         if sys.maxunicode != 65535:
  314.             return charset
  315.         
  316.         for i in range(65536):
  317.             charmap[i] = not charmap[i]
  318.         
  319.     
  320.     comps = { }
  321.     mapping = [
  322.         0] * 256
  323.     block = 0
  324.     data = []
  325.     for i in range(256):
  326.         chunk = tuple(charmap[i * 256:(i + 1) * 256])
  327.         new = comps.setdefault(chunk, block)
  328.         mapping[i] = new
  329.         if new == block:
  330.             block = block + 1
  331.             data = data + _mk_bitmap(chunk)
  332.             continue
  333.     
  334.     header = [
  335.         block]
  336.     if MAXCODE == 65535:
  337.         code = 'H'
  338.     else:
  339.         code = 'L'
  340.     mapping = array.array('b', mapping).tostring()
  341.     header = header + array.array(code, mapping).tolist()
  342.     data[0:0] = header
  343.     return [
  344.         (BIGCHARSET, data)]
  345.  
  346.  
  347. def _simple(av):
  348.     (lo, hi) = av[2].getwidth()
  349.     if lo == 0 and hi == MAXREPEAT:
  350.         raise error, 'nothing to repeat'
  351.     
  352.     if hi == hi:
  353.         pass
  354.     elif hi == 1:
  355.         pass
  356.     return av[2][0][0] != SUBPATTERN
  357.  
  358.  
  359. def _compile_info(code, pattern, flags):
  360.     (lo, hi) = pattern.getwidth()
  361.     if lo == 0:
  362.         return None
  363.     
  364.     prefix = []
  365.     prefix_skip = 0
  366.     charset = []
  367.     if not (flags & SRE_FLAG_IGNORECASE):
  368.         for op, av in pattern.data:
  369.             if op is LITERAL:
  370.                 if len(prefix) == prefix_skip:
  371.                     prefix_skip = prefix_skip + 1
  372.                 
  373.                 prefix.append(av)
  374.                 continue
  375.             if op is SUBPATTERN and len(av[1]) == 1:
  376.                 (op, av) = av[1][0]
  377.                 if op is LITERAL:
  378.                     prefix.append(av)
  379.                 else:
  380.                     break
  381.             op is LITERAL
  382.         
  383.         if not prefix and pattern.data:
  384.             (op, av) = pattern.data[0]
  385.             if op is SUBPATTERN and av[1]:
  386.                 (op, av) = av[1][0]
  387.                 if op is LITERAL:
  388.                     charset.append((op, av))
  389.                 elif op is BRANCH:
  390.                     c = []
  391.                     for p in av[1]:
  392.                         if not p:
  393.                             break
  394.                         
  395.                         (op, av) = p[0]
  396.                         if op is LITERAL:
  397.                             c.append((op, av))
  398.                             continue
  399.                     else:
  400.                         charset = c
  401.                 
  402.             elif op is BRANCH:
  403.                 c = []
  404.                 for p in av[1]:
  405.                     if not p:
  406.                         break
  407.                     
  408.                     (op, av) = p[0]
  409.                     if op is LITERAL:
  410.                         c.append((op, av))
  411.                         continue
  412.                 else:
  413.                     charset = c
  414.             elif op is IN:
  415.                 charset = av
  416.             
  417.         
  418.     
  419.     emit = code.append
  420.     emit(OPCODES[INFO])
  421.     skip = len(code)
  422.     emit(0)
  423.     mask = 0
  424.     if prefix:
  425.         mask = SRE_INFO_PREFIX
  426.         if prefix_skip == prefix_skip:
  427.             pass
  428.         elif prefix_skip == len(pattern.data):
  429.             mask = mask + SRE_INFO_LITERAL
  430.         
  431.     elif charset:
  432.         mask = mask + SRE_INFO_CHARSET
  433.     
  434.     emit(mask)
  435.     if lo < MAXCODE:
  436.         emit(lo)
  437.     else:
  438.         emit(MAXCODE)
  439.         prefix = prefix[:MAXCODE]
  440.     if hi < MAXCODE:
  441.         emit(hi)
  442.     else:
  443.         emit(0)
  444.     if prefix:
  445.         emit(len(prefix))
  446.         emit(prefix_skip)
  447.         code.extend(prefix)
  448.         table = [
  449.             -1] + [
  450.             0] * len(prefix)
  451.         for i in range(len(prefix)):
  452.             table[i + 1] = table[i] + 1
  453.             while table[i + 1] > 0 and prefix[i] != prefix[table[i + 1] - 1]:
  454.                 table[i + 1] = table[table[i + 1] - 1] + 1
  455.         
  456.         code.extend(table[1:])
  457.     elif charset:
  458.         _compile_charset(charset, flags, code)
  459.     
  460.     code[skip] = len(code) - skip
  461.  
  462.  
  463. try:
  464.     unicode
  465. except NameError:
  466.     STRING_TYPES = (type(''),)
  467.  
  468. STRING_TYPES = (type(''), type(unicode('')))
  469.  
  470. def isstring(obj):
  471.     for tp in STRING_TYPES:
  472.         if isinstance(obj, tp):
  473.             return 1
  474.             continue
  475.     
  476.     return 0
  477.  
  478.  
  479. def _code(p, flags):
  480.     flags = p.pattern.flags | flags
  481.     code = []
  482.     _compile_info(code, p, flags)
  483.     _compile(code, p.data, flags)
  484.     code.append(OPCODES[SUCCESS])
  485.     return code
  486.  
  487.  
  488. def compile(p, flags = 0):
  489.     if isstring(p):
  490.         import sre_parse
  491.         pattern = p
  492.         p = sre_parse.parse(p, flags)
  493.     else:
  494.         pattern = None
  495.     code = _code(p, flags)
  496.     if not p.pattern.groups <= 100:
  497.         raise AssertionError, 'sorry, but this version only supports 100 named groups'
  498.     groupindex = p.pattern.groupdict
  499.     indexgroup = [
  500.         None] * p.pattern.groups
  501.     for k, i in groupindex.items():
  502.         indexgroup[i] = k
  503.     
  504.     return _sre.compile(pattern, flags, code, p.pattern.groups - 1, groupindex, indexgroup)
  505.  
  506.